home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / corelib / ncbimain.dos < prev    next >
Encoding:
Text File  |  1996-07-05  |  8.9 KB  |  324 lines  |  [TEXT/R*ch]
  1. /*   ncbimain.c
  2. * ===========================================================================
  3. *
  4. *                            PUBLIC DOMAIN NOTICE                          
  5. *               National Center for Biotechnology Information
  6. *                                                                          
  7. *  This software/database is a "United States Government Work" under the   
  8. *  terms of the United States Copyright Act.  It was written as part of    
  9. *  the author's official duties as a United States Government employee and 
  10. *  thus cannot be copyrighted.  This software/database is freely available 
  11. *  to the public for use. The National Library of Medicine and the U.S.    
  12. *  Government have not placed any restriction on its use or reproduction.  
  13. *                                                                          
  14. *  Although all reasonable efforts have been taken to ensure the accuracy  
  15. *  and reliability of the software and data, the NLM and the U.S.          
  16. *  Government do not and cannot warrant the performance or results that    
  17. *  may be obtained by using this software or data. The NLM and the U.S.    
  18. *  Government disclaim all warranties, express or implied, including       
  19. *  warranties of performance, merchantability or fitness for any particular
  20. *  purpose.                                                                
  21. *                                                                          
  22. *  Please cite the author in any work or product based on this material.   
  23. *
  24. * ===========================================================================
  25. *
  26. * File Name:  ncbimain.c
  27. *
  28. * Author:  Ostell
  29. *
  30. * Version Creation Date:   2/25/91
  31. *
  32. * Version Number:  1.1
  33. *
  34. * File Description: 
  35. *       portable main() and argc, argv handling
  36. *       DOS version for dumb terminals
  37. *
  38. * Modifications:  
  39. * --------------------------------------------------------------------------
  40. * Date     Name        Description of modification
  41. * -------  ----------  -----------------------------------------------------
  42. * 2/25/91  Ostell      add support to GetArgs for args separated from tags
  43. *
  44. * ==========================================================================
  45. */
  46.  
  47. #include <ncbi.h>
  48. #include <ncbiwin.h>
  49.  
  50. /*****************************************************************************
  51. *
  52. *   main()
  53. *     this replaces the normal program main()
  54. *     handles argc and argv
  55. *     does any required windows initialization
  56. *
  57. *****************************************************************************/
  58. static int targc;
  59. static char ** targv;
  60.  
  61. int main (int argc, char *argv[])
  62.  
  63. {
  64.     Nlm_Int2 retval;
  65.  
  66.     targc = argc;
  67.     targv = argv;
  68.  
  69. #ifdef MSC_VIRT
  70.     if (! _vheapinit(0, 1250, _VM_ALLSWAP))
  71.     {
  72.         ErrPost(CTX_NCBIOBJ, 1, "Can't open virtual memory");
  73.         return 1;
  74.     }
  75. #endif
  76.  
  77.     retval = Nlm_Main();
  78.                        /**** do any cleanup here *************/
  79.     Nlm_FreeConfigStruct ();
  80.  
  81. #ifdef MSC_VIRT
  82.     _vheapterm();
  83. #endif
  84.     return retval;
  85. }
  86. #define MAX_ARGS 50       /* maximum args this can process */
  87. /*****************************************************************************
  88. *
  89. *   Nlm_GetArgs(ap)
  90. *       returns user startup arguments
  91. *
  92. *****************************************************************************/
  93. Nlm_Boolean Nlm_GetArgs (Nlm_CharPtr progname, Nlm_Int2 numargs, Nlm_ArgPtr ap)
  94.  
  95. {
  96.     static Nlm_CharPtr types[9] = {
  97.         NULL,
  98.         "T/F",
  99.         "Integer",
  100.         "Real",
  101.         "String",
  102.         "File In",
  103.         "File Out",
  104.         "Data In",
  105.         "Data Out" };
  106.     Nlm_Boolean okay = FALSE, all_default = TRUE, range;
  107.     Nlm_Int2 i, j;
  108.     Nlm_Int4 ifrom, ito;
  109.     Nlm_FloatHi ffrom, fto;
  110.     Nlm_ArgPtr curarg;
  111.     Nlm_Boolean resolved[MAX_ARGS];
  112.     Nlm_CharPtr arg;
  113.     Nlm_Char tmp;
  114.     Nlm_Boolean ok;
  115.  
  116.     if ((ap == NULL) || (numargs == 0) || (numargs > MAX_ARGS))
  117.         return okay;
  118.  
  119.     curarg = ap;                        /* set defaults */
  120.     Nlm_MemFill(resolved, '\0', (MAX_ARGS * sizeof(Nlm_Boolean)));
  121.  
  122.     for (i = 0; i < numargs; i++, curarg++)
  123.     {
  124.         if ((curarg->type < ARG_BOOLEAN) ||
  125.              (curarg->type > ARG_DATA_OUT))
  126.         {
  127.             Message(MSG_ERROR, "Invalid Arg->type in %s", curarg->prompt);
  128.             return okay;
  129.         }
  130.         curarg->intvalue = 0;
  131.         curarg->floatvalue = 0.0;
  132.         curarg->strvalue = NULL;
  133.         if (curarg->defaultvalue != NULL)
  134.         {
  135.             resolved[i] = TRUE;
  136.             switch (curarg->type)
  137.             {
  138.                 case ARG_BOOLEAN:
  139.                     if (TO_UPPER(*curarg->defaultvalue) == 'T')
  140.                         curarg->intvalue = 1;
  141.                     else
  142.                         curarg->intvalue = 0;
  143.                     break;
  144.                 case ARG_INT:
  145.                     sscanf(curarg->defaultvalue, "%ld", &curarg->intvalue);
  146.                     break;
  147.                 case ARG_FLOAT:
  148.                     sscanf(curarg->defaultvalue, "%lf", &curarg->floatvalue);
  149.                     break;
  150.                 case ARG_STRING:
  151.                 case ARG_FILE_IN:
  152.                 case ARG_FILE_OUT:
  153.                 case ARG_DATA_IN:
  154.                 case ARG_DATA_OUT:
  155.                     curarg->strvalue = StringSave (curarg->defaultvalue);
  156.                     break;
  157.             }
  158.         }
  159.         else if (curarg->optional == FALSE)
  160.             all_default = FALSE;    /* must have some arguments */
  161.     }
  162.                           /**** show usage if no args on command line ***/
  163.     if ((targc == 1) && (all_default == TRUE))   /* no args ok */
  164.         return TRUE;
  165.  
  166.     if ((targc == 1) || (*(targv[1]+1) == '\0'))
  167.     {
  168.         printf("\n%s   arguments:\n\n", progname);
  169.         curarg = ap;
  170.  
  171.         for (i = 0, j=0; i < numargs; i++, j++, curarg++)
  172.         {
  173.             printf("  -%c  %s [%s]", curarg->tag, curarg->prompt,
  174.                 types[curarg->type]);
  175.             if (curarg->optional)
  176.                 printf("  Optional");
  177.             printf("\n");
  178.             if (curarg->defaultvalue != NULL)
  179.                 printf("    default = %s\n", curarg->defaultvalue);
  180.             if ((curarg->from != NULL) || (curarg->to != NULL))
  181.             {
  182.                 if ((curarg->type == ARG_DATA_IN) ||
  183.                     (curarg->type == ARG_DATA_OUT))
  184.                     printf("    Data Type = %s\n", curarg->from);
  185.                 else
  186.                     printf("    range from %s to %s\n", curarg->from, curarg->to);
  187.             }
  188.         }
  189.         printf("\n");
  190.         return okay;
  191.     }
  192.  
  193.     for (i = 1; i < targc; i++)
  194.     {
  195.         arg = targv[i];
  196.         if (*arg != '-')
  197.         {
  198.             Message(MSG_ERROR, "Arguments must start with -");
  199.             return okay;
  200.         }
  201.         arg++;
  202.         curarg = ap;
  203.         for (j = 0; j < numargs; j++, curarg++)
  204.         {
  205.             if (*arg == curarg->tag)
  206.                 break;
  207.         }
  208.         if (j == numargs)
  209.         {
  210.             Message(MSG_ERROR, "Invalid argument: %s", targv[i]);
  211.             return okay;
  212.         }
  213.         arg++;
  214.         if (*arg == '\0')
  215.         {
  216.             ok = FALSE;
  217.             if ((i + 1) < targc)  /* argument comes after space */
  218.             {
  219.                 if (*targv[i + 1] == '-')
  220.                 {
  221.                     tmp = *(targv[i+1]+1);
  222.                     if (((curarg->type == ARG_INT) || (curarg->type == ARG_FLOAT)) &&
  223.                         ((tmp == '.') || (IS_DIGIT(tmp))))
  224.                         ok = TRUE;
  225.                 }
  226.                 else
  227.                     ok = TRUE;
  228.                 if (ok)
  229.                 {
  230.                     i++;
  231.                     arg = targv[i];
  232.                 }
  233.             }
  234.  
  235.             if ((!ok) && (curarg->type != ARG_BOOLEAN))
  236.             {
  237.                 Message(MSG_ERROR, "No argument given for %s", curarg->prompt);
  238.                 return okay;
  239.             }
  240.         }
  241.         resolved[j] = TRUE;
  242.         switch (curarg->type)
  243.         {
  244.             case ARG_BOOLEAN:
  245.                 if (TO_UPPER(*arg) == 'T')
  246.                     curarg->intvalue = 1;
  247.                 else if (TO_UPPER(*arg) == 'F')
  248.                     curarg->intvalue = 0;
  249.                 else if (*arg == '\0')
  250.                     curarg->intvalue = 1;
  251.                 break;
  252.             case ARG_INT:
  253.                 sscanf(arg, "%ld", &curarg->intvalue);
  254.                 if ((curarg->from != NULL) || (curarg->to != NULL))
  255.                 {
  256.                     range = TRUE;
  257.                     if (curarg->from != NULL)
  258.                     {
  259.                         sscanf(curarg->from, "%ld", &ifrom);
  260.                         if (curarg->intvalue < ifrom)
  261.                             range = FALSE;
  262.                     }
  263.                     if (curarg->to != NULL)
  264.                     {              
  265.                         sscanf(curarg->to, "%ld", &ito);
  266.                         if (curarg->intvalue > ito)
  267.                             range = FALSE;
  268.                     }
  269.                     if (! range)
  270.                     {
  271.                         Message(MSG_ERROR, "%s [%ld] is out of range [%s to %s]", curarg->prompt,
  272.                             curarg->intvalue, curarg->from, curarg->to);
  273.                         return okay;
  274.                     }
  275.                 }
  276.                  break;
  277.             case ARG_FLOAT:
  278.                 sscanf(arg, "%lf", &curarg->floatvalue);
  279.                 if ((curarg->from != NULL) || (curarg->to != NULL))
  280.                 {
  281.                     range = TRUE;
  282.                     if (curarg->from != NULL)
  283.                     {
  284.                         sscanf(curarg->from, "%lf", &ffrom);
  285.                         if (curarg->floatvalue < ffrom)
  286.                             range = FALSE;
  287.                     }
  288.                     if (curarg->to != NULL)
  289.                     {
  290.                         sscanf(curarg->to, "%lf", &fto);
  291.                         if (curarg->floatvalue > fto)
  292.                             range = FALSE;
  293.                     }
  294.                     if (! range)
  295.                     {
  296.                         Message(MSG_ERROR, "%s [%g] is out of range [%s to %s]", curarg->prompt, 
  297.                             curarg->floatvalue, curarg->from, curarg->to);
  298.                         return okay;
  299.                     }
  300.                 }
  301.                 break;
  302.             case ARG_STRING:
  303.             case ARG_FILE_IN:
  304.             case ARG_FILE_OUT:
  305.             case ARG_DATA_IN:
  306.             case ARG_DATA_OUT:
  307.                 curarg->strvalue = StringSave (arg);
  308.                 break;
  309.         }    /*** end switch ****/
  310.     }       
  311.     curarg = ap;
  312.     okay = TRUE;
  313.     for (i = 0; i < numargs; i++, curarg++)
  314.     {
  315.         if ((! curarg->optional) && (! resolved[i]))
  316.         {
  317.             Message(MSG_ERROR, "%s was not given an argument", curarg->prompt);
  318.             okay = FALSE;
  319.         }
  320.     }
  321.     return okay;
  322. }
  323.  
  324.